home *** CD-ROM | disk | FTP | other *** search
/ Programming a Multiplayer FPS in DirectX / Programming a Multiplayer FPS in DirectX (Companion CD).iso / DirectX / dxsdk_oct2004.exe / dxsdk.exe / Utilities / Content Creation Tool Plug-Ins / Maya / Sources / PreviewPipeline.cpp < prev    next >
Encoding:
C/C++ Source or Header  |  2004-09-27  |  13.5 KB  |  677 lines
  1. #include "dxstdafx.h"
  2. #include "PreviewPipeline.h"
  3.  
  4.  
  5. HRESULT CPipeline::Create() 
  6. { 
  7.     LPDXCCRESOURCE pResource= NULL;
  8.     pPreviewEngine= NULL;
  9.     fTime= 0;
  10.     DXCCCreateManager(&pDXCCManager);
  11.     DXCCCreateFrame(&pDXCCRoot);
  12.     pDXCCManager->CreateResource(pDXCCRoot, IID_IDXCCFrame, TRUE, &pResource);
  13.     pResource->SetName("DXCC_ROOT");
  14.     DXCC_RELEASE(pResource);
  15.  
  16.     ReadWriteMutex= CreateMutexA(NULL, FALSE, "DXCCPipeline_SceneReadWriteLock");
  17.     InitializeCriticalSection(&ZeroSceneReadersSection);
  18.     SceneReadersCount= 0;
  19.     ZeroSceneReadersEvent= CreateEventA(NULL, TRUE, TRUE, "DXCCPipeline_ZeroReaders");
  20.  
  21.     return S_OK; 
  22. }
  23.  
  24. HRESULT CPipeline::Destroy() 
  25. { 
  26.  
  27.     DXCC_RELEASE(pDXCCRoot);
  28.     DXCC_RELEASE(pDXCCManager);
  29.     CloseHandle(ReadWriteMutex);
  30.     ReadWriteMutex= NULL;
  31.     CloseHandle(ZeroSceneReadersEvent);
  32.     ZeroSceneReadersEvent= NULL;
  33.     DeleteCriticalSection(&ZeroSceneReadersSection);
  34.         
  35.     return S_OK; 
  36. }
  37.  
  38. HRESULT CPipeline::SetEngine( CPipelineEngine* pPreviewPipelineEngine )  
  39. { 
  40.     TriggerDeviceEvents.OnD3DDeviceDestroy();
  41.     pPreviewEngine= pPreviewPipelineEngine; 
  42.     TriggerDeviceEvents.OnD3DDeviceCreate();
  43.     return S_OK;
  44. }
  45.  
  46.  
  47.  
  48. void CPipeline::SetTime(float time) 
  49. {
  50.     fTime= time;
  51. }
  52.  
  53. float CPipeline::GetTime() 
  54. {
  55.     return fTime;
  56. }
  57.  
  58. CPipelineEngine* 
  59. CPipeline::AccessEngine()
  60. {
  61.     return pPreviewEngine;
  62. }
  63.  
  64. LPDXCCMANAGER
  65. CPipeline::AccessManager()
  66. {
  67.     return pDXCCManager;
  68. }
  69.  
  70. LPDXCCFRAME 
  71. CPipeline::AccessRoot()
  72. {
  73.     return pDXCCRoot;
  74. }
  75.  
  76.  
  77. bool CPipeline::SceneWriteLock(BOOL WaitForLock, CPipelineLock& Lock) 
  78. {
  79.     if(Lock.isLocked()==false)
  80.     {
  81.         if(GetSingleObject(WaitForLock, ReadWriteMutex))
  82.         {
  83.             if(GetSingleObject(WaitForLock, ZeroSceneReadersEvent))
  84.             {
  85.                 Lock.Locked=true;
  86.                 Lock.Type=CPipelineLock::TYPE_SCENE_WRITE;
  87.                 Lock.pPreviewPipeline=this;
  88.                 return true;
  89.             }
  90.             else
  91.             {
  92.                 ReleaseMutex(ReadWriteMutex);
  93.                 return false;
  94.             }
  95.         }
  96.         else
  97.             return false;
  98.     }
  99.     else
  100.         return false;
  101. }
  102.     
  103. void CPipeline::SceneWriteUnlock(CPipelineLock& Lock) 
  104. {
  105.     if(Lock.isLocked()==true && Lock.ofType()==CPipelineLock::TYPE_SCENE_WRITE)
  106.     {
  107.         Lock.Locked=false;
  108.         Lock.pPreviewPipeline=NULL;
  109.  
  110.         ReleaseMutex(ReadWriteMutex);
  111.     }
  112. }
  113. CPipelineLock::CPipelineLock(bool AutoUnlock)
  114. {
  115.     Type=TYPE_NONE; 
  116.     Locked=false; 
  117.     UnlockOnDestuction= AutoUnlock;
  118.     pPreviewPipeline=NULL; 
  119. };
  120.  
  121. CPipelineLock::~CPipelineLock()
  122. {
  123.     if(Locked && UnlockOnDestuction && pPreviewPipeline)
  124.     {
  125.         switch(Type)
  126.         {
  127.  
  128.         case TYPE_SCENE_WRITE:
  129.             pPreviewPipeline->SceneWriteUnlock(*this);
  130.             break;
  131.         case TYPE_SCENE_READ:
  132.             pPreviewPipeline->SceneReadUnlock(*this);
  133.             break;
  134.         };
  135.     }
  136. }
  137.  
  138. bool CPipeline::SceneReadLock(BOOL WaitForLock, CPipelineLock& Lock)
  139. {
  140.     if(Lock.isLocked()==false)
  141.     {
  142.         if(GetSingleObject(WaitForLock, ReadWriteMutex))
  143.         {
  144.             //EnterCriticalSection(&ZeroSceneReadersSection); //using ReadWriteMutex instead
  145.             if(0==SceneReadersCount)
  146.                 ResetEvent(ZeroSceneReadersEvent);
  147.             ++SceneReadersCount; //InterlockedIncrement(&SceneReadersCount);//using ReadWriteMutex instead
  148.             //LeaveCriticalSection(&ZeroSceneReadersSection); //using ReadWriteMutex instead
  149.  
  150.             ReleaseMutex(ReadWriteMutex);
  151.  
  152.             Lock.Locked=true;
  153.             Lock.Type=CPipelineLock::TYPE_SCENE_READ;
  154.             Lock.pPreviewPipeline=this;
  155.  
  156.             return true;
  157.         }
  158.         else
  159.             return false;
  160.     }
  161.     else
  162.         return false;
  163.  
  164. }
  165.  
  166.  
  167. void CPipeline::SceneReadUnlock(CPipelineLock& Lock)
  168. {
  169.     if(Lock.isLocked()==true && Lock.ofType()==CPipelineLock::TYPE_SCENE_READ)
  170.     {
  171.         EnterCriticalSection(&ZeroSceneReadersSection); 
  172.  
  173.         Lock.Locked=false;
  174.         Lock.pPreviewPipeline=NULL;
  175.         
  176.         if(SceneReadersCount > 0
  177.             && 0== --SceneReadersCount)
  178.         {
  179.             SetEvent(ZeroSceneReadersEvent);
  180.         }
  181.         
  182.         LeaveCriticalSection(&ZeroSceneReadersSection);
  183.     }
  184. }
  185.  
  186. bool CPipeline::IsValid()
  187. {
  188.     return (pPreviewEngine && pDXCCManager && pDXCCRoot);
  189. }
  190.  
  191. HRESULT CPipelineEngineEventsTrigger::RegisterEvents(CPipelineEngineEvents* pCall)
  192. {
  193.     UnregisterEvents(pCall);
  194.     Events.push_back(pCall);
  195.     return S_OK;
  196. }
  197.  
  198. HRESULT CPipelineEngineEventsTrigger::UnregisterEvents(CPipelineEngineEvents* pCall) 
  199. {
  200.     for(UINT i= 0; 
  201.         i < Events.size(); 
  202.         i++)
  203.     {
  204.         const CPipelineEngineEvents* &event= Events.at(i);
  205.         if(event==pCall)
  206.         {
  207.             Events.erase( Events.begin( ) + i);
  208.             return S_OK;
  209.         }
  210.     }
  211.     
  212.     return E_INVALIDARG;
  213. }
  214.  
  215. HRESULT CPipelineManagerEventsTrigger::RegisterEvents(CPipelineManagerEvents* pCall)
  216. {
  217.     UnregisterEvents(pCall);
  218.     Events.push_back(pCall);
  219.     return S_OK;
  220. }
  221.  
  222. HRESULT CPipelineManagerEventsTrigger::UnregisterEvents(CPipelineManagerEvents* pCall)
  223. {
  224.     for(UINT i= 0; 
  225.         i < Events.size(); 
  226.         i++)
  227.     {
  228.         const CPipelineManagerEvents* &event= Events.at(i);
  229.         if(event==pCall)
  230.         {
  231.             Events.erase( Events.begin( ) + i);
  232.             return S_OK;
  233.         }
  234.     }
  235.     
  236.     return E_INVALIDARG;
  237. }
  238.  
  239. HRESULT CPipelineViewerEventsTrigger::RegisterEvents(CPipelineViewerEvents* pCall)
  240. {
  241.     UnregisterEvents(pCall);
  242.     Events.push_back(pCall);
  243.     return S_OK;
  244. }
  245.  
  246. HRESULT CPipelineViewerEventsTrigger::UnregisterEvents(CPipelineViewerEvents* pCall)
  247. {
  248.     for(UINT i= 0; 
  249.         i < Events.size(); 
  250.         i++)
  251.     {
  252.         const CPipelineViewerEvents* &event= Events.at(i);
  253.         if(event==pCall)
  254.         {
  255.             Events.erase( Events.begin( ) + i);
  256.             return S_OK;
  257.         }
  258.     }
  259.     
  260.     return E_INVALIDARG;
  261. }
  262.  
  263.  
  264.  
  265. HRESULT CPipelineEngineEventsTrigger::OnD3DDeviceCreate()
  266. {
  267.     HRESULT hr= S_OK;
  268.     for(UINT i= 0; 
  269.         i < Events.size() 
  270.         && hr == S_OK; 
  271.         i++)
  272.     {
  273.         CPipelineEngineEvents* &event= Events.at(i);
  274.         hr= event->OnD3DDeviceCreate();
  275.     }
  276.     return hr;
  277. };
  278.  
  279. HRESULT CPipelineEngineEventsTrigger::OnD3DDeviceReset()
  280. {
  281.     HRESULT hr= S_OK;
  282.     for(UINT i= 0; 
  283.         i < Events.size() 
  284.         && hr == S_OK; 
  285.         i++)
  286.     {
  287.         CPipelineEngineEvents* &event= Events.at(i);
  288.         hr= event->OnD3DDeviceReset();
  289.     }
  290.     return hr;
  291. };
  292.  
  293. HRESULT CPipelineEngineEventsTrigger::OnD3DDeviceLost()
  294. {
  295.     HRESULT hr= S_OK;
  296.     for(UINT i= 0; 
  297.         i < Events.size() 
  298.         && hr == S_OK; 
  299.         i++)
  300.     {
  301.         CPipelineEngineEvents* &event= Events.at(i);
  302.         hr= event->OnD3DDeviceLost();
  303.     }
  304.     return hr;
  305. };
  306.  
  307. HRESULT CPipelineEngineEventsTrigger::OnD3DDeviceDestroy()
  308. {
  309.     HRESULT hr= S_OK;
  310.     for(UINT i= 0;
  311.         i < Events.size() 
  312.         && hr == S_OK; 
  313.         i++)
  314.     {
  315.         CPipelineEngineEvents* &event= Events.at(i);
  316.         hr= event->OnD3DDeviceDestroy();
  317.     }
  318.     return hr;
  319. };
  320.  
  321.  
  322. HRESULT CPipelineManagerEventsTrigger::OnReload()
  323. {
  324.     HRESULT hr= S_OK;
  325.     for(UINT i= 0; 
  326.         i < Events.size() 
  327.         && hr == S_OK; 
  328.         i++)
  329.     {
  330.         CPipelineManagerEvents* &event= Events.at(i);
  331.         hr= event->OnReload();
  332.     }
  333.     return hr;
  334. };
  335.  
  336. HRESULT CPipelineManagerEventsTrigger::OnResourceAdd(IDXCCResource* pRes)
  337. {
  338.     HRESULT hr= S_OK;
  339.     for(UINT i= 0; 
  340.         i < Events.size() 
  341.         && hr == S_OK; 
  342.         i++)
  343.     {
  344.         CPipelineManagerEvents* &event= Events.at(i);
  345.         hr= event->OnResourceAdd(pRes);
  346.     }
  347.     return hr;
  348. };
  349.  
  350.  
  351. CPipelineManagerEvents::CPipelineManagerEvents()
  352. {
  353.     ExclusiveModeMutex= CreateMutex(NULL, false, NULL);
  354. }
  355.  
  356. CPipelineManagerEvents::~CPipelineManagerEvents()
  357. {
  358.     CloseHandle(ExclusiveModeMutex);
  359.  
  360. }
  361.  
  362.  
  363. HRESULT CPipelineManagerEventsTrigger::OnResourceRecycle(IDXCCResource* pRes)
  364. {
  365.     HRESULT hr= S_OK;
  366.     for(UINT i= 0; 
  367.         i < Events.size() 
  368.         && hr == S_OK; 
  369.         i++)
  370.     {
  371.         CPipelineManagerEvents* &event= Events.at(i);
  372.         hr= event->OnResourceRecycle(pRes);
  373.     }
  374.     return hr;
  375. };
  376.  
  377. HRESULT CPipelineManagerEventsTrigger::OnResourceRemove(IDXCCResource* pRes)
  378. {
  379.     HRESULT hr= S_OK;
  380.     for(UINT i= 0; 
  381.         i < Events.size() 
  382.         && hr == S_OK; 
  383.         i++)
  384.     {
  385.         CPipelineManagerEvents* &event= Events.at(i);
  386.         hr=event->OnResourceRemove(pRes);
  387.     }
  388.     return hr;
  389. };
  390.  
  391. HRESULT CPipelineViewerEventsTrigger::OnFrameChildAdded(IDXCCFrame* pParent, IDXCCFrame* pChild)
  392. {
  393.     HRESULT hr= S_OK;
  394.     for(UINT i= 0; 
  395.         i < Events.size() 
  396.         && hr == S_OK; 
  397.         i++)
  398.     {
  399.         CPipelineViewerEvents* &event= Events.at(i);
  400.         hr= event->OnFrameChildAdded(pParent, pChild);
  401.     }
  402.     return hr;
  403. };
  404.  
  405. HRESULT CPipelineViewerEventsTrigger::OnFrameChildRemoved(IDXCCFrame* pParent, IDXCCFrame* pChild) 
  406. {
  407.     HRESULT hr= S_OK;
  408.     for(UINT i= 0; 
  409.         i < Events.size() 
  410.         && hr == S_OK; 
  411.         i++)
  412.     {
  413.         CPipelineViewerEvents* &event= Events.at(i);
  414.         hr= event->OnFrameChildRemoved(pParent, pChild);
  415.     }
  416.     return hr;
  417. };
  418.  
  419. HRESULT CPipelineViewerEventsTrigger::OnFrameMemberAdded(IDXCCFrame* pParent, IUnknown* pChild)
  420. {
  421.     HRESULT hr= S_OK;
  422.     for(UINT i= 0; 
  423.         i < Events.size() 
  424.         && hr == S_OK; 
  425.         i++)
  426.     {
  427.         CPipelineViewerEvents* &event= Events.at(i);
  428.         hr= event->OnFrameMemberAdded(pParent, pChild);
  429.     }
  430.     return hr;
  431. };
  432.  
  433. HRESULT CPipelineViewerEventsTrigger::OnFrameMemberRemoved(IDXCCFrame* pParent, IUnknown* pChild)
  434. {
  435.     HRESULT hr= S_OK;
  436.     for(UINT i= 0; 
  437.         i < Events.size() 
  438.         && hr == S_OK; 
  439.         i++)
  440.     {
  441.         CPipelineViewerEvents* &event= Events.at(i);
  442.         hr= event->OnFrameMemberRemoved(pParent, pChild);
  443.     }
  444.     return hr;
  445. };
  446.  
  447. HRESULT CPipelineViewerEventsTrigger::OnMeshChange(IDXCCMesh* pMesh)
  448. {
  449.     HRESULT hr= S_OK;
  450.     for(UINT i= 0; 
  451.         i < Events.size() 
  452.         && hr == S_OK; 
  453.         i++)
  454.     {
  455.         CPipelineViewerEvents* &event= Events.at(i);
  456.         hr= event->OnMeshChange(pMesh);
  457.     }
  458.     return hr;
  459. };
  460.  
  461. HRESULT CPipelineViewerEventsTrigger::OnMeshDeclarationChange(IDXCCMesh* pMesh, IDXCCMesh* pOldMesh)
  462. {
  463.     HRESULT hr= S_OK;
  464.     for(UINT i= 0; 
  465.         i < Events.size() 
  466.         && hr == S_OK; 
  467.         i++)
  468.     {
  469.         CPipelineViewerEvents* &event= Events.at(i);
  470.         hr= event->OnMeshDeclarationChange(pMesh, pOldMesh);
  471.     }
  472.     return hr;
  473. };
  474.  
  475. HRESULT CPipelineViewerEventsTrigger::OnMeshTopologyChange(IDXCCMesh* pMesh, IDXCCMesh* pOldMesh)
  476. {
  477.     HRESULT hr= S_OK;
  478.     for(UINT i= 0; 
  479.         i < Events.size() 
  480.         && hr == S_OK; 
  481.         i++)
  482.     {
  483.         CPipelineViewerEvents* &event= Events.at(i);
  484.         hr= event->OnMeshTopologyChange(pMesh, pOldMesh);
  485.     }
  486.     return hr;
  487. };
  488.  
  489. HRESULT CPipelineViewerEventsTrigger::OnMeshVertexChange(IDXCCMesh* pMesh, UINT vertMin, UINT vertMax)
  490. {
  491.     HRESULT hr= S_OK;
  492.     for(UINT i= 0; 
  493.         i < Events.size() 
  494.         && hr == S_OK; 
  495.         i++)
  496.     {
  497.         CPipelineViewerEvents* &event= Events.at(i);
  498.         hr= event->OnMeshVertexChange(pMesh, vertMin, vertMax);
  499.     }
  500.     return hr;
  501. };
  502.  
  503. HRESULT CPipelineViewerEventsTrigger::OnMeshSubVertexChange(IDXCCMesh* pMesh, D3DDECLUSAGE Usage, UINT UsageIndex, UINT vertMin, UINT vertMax)
  504. {
  505.     HRESULT hr= S_OK;
  506.     for(UINT i= 0; 
  507.         i < Events.size() 
  508.         && hr == S_OK; 
  509.         i++)
  510.     {
  511.         CPipelineViewerEvents* &event= Events.at(i);
  512.         hr= event->OnMeshSubVertexChange(pMesh, Usage, UsageIndex, vertMin, vertMax);
  513.     }
  514.     return hr;
  515. };
  516. HRESULT CPipelineViewerEventsTrigger::OnMeshAttributeChange(IDXCCMesh* pMesh, UINT faceMin, UINT faceMax)
  517. {
  518.     HRESULT hr= S_OK;
  519.     for(UINT i= 0; 
  520.         i < Events.size() 
  521.         && hr == S_OK; 
  522.         i++)
  523.     {
  524.         CPipelineViewerEvents* &event= Events.at(i);
  525.         hr= event->OnMeshAttributeChange(pMesh, faceMin, faceMax);
  526.     }
  527.     return hr;
  528. };
  529.  
  530. HRESULT CPipelineViewerEventsTrigger::OnMeshMaterialChange(IDXCCMesh* pMesh, DXCCATTRIBUTE Attrib, ID3DXEffect* pOldMaterial)
  531. {
  532.     HRESULT hr= S_OK;
  533.     for(UINT i= 0; 
  534.         i < Events.size() 
  535.         && hr == S_OK; 
  536.         i++)
  537.     {
  538.         CPipelineViewerEvents* &event= Events.at(i);
  539.         hr= event->OnMeshMaterialChange(pMesh, Attrib, pOldMaterial);
  540.     }
  541.     return hr;
  542. };
  543.  
  544. HRESULT CPipelineViewerEventsTrigger::OnMaterialEffectChange(ID3DXEffect* pMaterial, LPD3DXEFFECT pOldEffect)
  545. {
  546.     HRESULT hr= S_OK;
  547.     for(UINT i= 0; 
  548.         i < Events.size() 
  549.         && hr == S_OK; 
  550.         i++)
  551.     {
  552.         CPipelineViewerEvents* &event= Events.at(i);
  553.         hr= event->OnMaterialEffectChange(pMaterial, pOldEffect);
  554.     }
  555.     return hr;
  556. };
  557.  
  558. HRESULT CPipelineViewerEventsTrigger::OnMaterialParameterChange(ID3DXEffect* pMaterial, D3DXHANDLE hParameter)
  559. {
  560.     HRESULT hr= S_OK;
  561.     for(UINT i= 0; 
  562.         i < Events.size() 
  563.         && hr == S_OK; 
  564.         i++)
  565.     {
  566.         CPipelineViewerEvents* &event= Events.at(i);
  567.         hr= event->OnMaterialParameterChange(pMaterial, hParameter);
  568.     }
  569.     return hr;
  570. };
  571.  
  572.  
  573.  
  574. CBank::CBank()
  575. {
  576.     GroupGenerator= 0;
  577.     ItemGenerator= 0;
  578. };
  579.  
  580. CBank::GroupId
  581. CBank::GenerateGroupId()
  582. {
  583.     return GroupGenerator++;
  584. }
  585.  
  586.  
  587. CBank::CItemBank::CPair* 
  588. CBank::AddItemToGroup(GroupId Gid, void* pValue)
  589. {
  590.     POSITION result = ItemBank.SetAt(ItemGenerator, pValue);
  591.     if(result)
  592.     {
  593.         GroupBank.Insert(Gid, ItemGenerator);
  594.         ItemToGroup.SetAt(ItemGenerator, Gid);
  595.     }
  596.     return ( result ? ItemBank.GetAt(result) : NULL);
  597. }
  598.  
  599.  
  600. void 
  601. CBank::RemoveByItem( ItemId Iid , bool DeleteValue)
  602. {
  603.     POSITION IidToGid= ItemToGroup.Lookup(Iid);
  604.     if(IidToGid)
  605.     {
  606.         GroupId Gid= ItemToGroup.GetAt(IidToGid)->m_value;
  607.  
  608.         for( POSITION pos= GroupBank.FindFirstWithKey(Gid);
  609.             pos != NULL;
  610.             GroupBank.GetNextWithKey(pos, Gid))
  611.         {
  612.             if(Iid == GroupBank.GetValueAt(pos))
  613.             {
  614.                 GroupBank.RemoveAt(pos);
  615.                 break;
  616.             }
  617.         }
  618.  
  619.         ItemToGroup.RemoveAt(IidToGid);
  620.     }
  621.     
  622.     POSITION valuePosition= ItemBank.Lookup(Iid);
  623.     if(valuePosition)
  624.     {
  625.         if(DeleteValue)
  626.         {
  627.             delete ItemBank.GetValueAt(valuePosition);
  628.         }
  629.         ItemBank.RemoveAt(valuePosition);
  630.     }
  631. }
  632.  
  633. void 
  634. CBank::RemoveByGroup( GroupId Gid , bool DeleteValues)
  635. {
  636.     for( POSITION pos= GroupBank.FindFirstWithKey(Gid);
  637.         pos != NULL;
  638.         GroupBank.GetNextWithKey(pos, Gid))
  639.     {
  640.         ItemId Iid = GroupBank.GetValueAt(pos);
  641.  
  642.         ItemToGroup.RemoveKey(Iid);
  643.  
  644.         POSITION valuePosition= ItemBank.Lookup(Iid);
  645.         if(valuePosition)
  646.         {
  647.             if(DeleteValues)
  648.             {
  649.                 delete ItemBank.GetValueAt(valuePosition);
  650.             }
  651.             ItemBank.RemoveAt(valuePosition);
  652.         }
  653.     }
  654.  
  655.     GroupBank.RemoveKey(Gid);
  656. }
  657.  
  658.  
  659. void 
  660. CBank::RemoveAll(bool DeleteValues)
  661. {
  662.     if(DeleteValues)
  663.     {
  664.         for( POSITION pos= ItemBank.GetHeadPosition();
  665.             pos != NULL;
  666.             GroupBank.GetNext(pos))
  667.         {
  668.             delete ItemBank.GetValueAt(pos);
  669.         }
  670.     }
  671.  
  672.     ItemBank.RemoveAll();
  673.     GroupBank.RemoveAll();
  674.     ItemToGroup.RemoveAll();
  675. }
  676.  
  677.